everyday-types

everyday-types

Everyday utility types

npm i everyday-types

pnpm add everyday-types

yarn add everyday-types

API

# AAt

src/string.ts#L3

A extends List ? number extends A ["length"] ? K extends number | template-literal ? A [never] | undefined : undefined : K extends keyof A ? A [K] : undefined : unknown extends A ? unknown : K extends keyof A ? A [K] : undefined

# Cast

src/string.ts#L42

A1 extends A2 ? A1 : A2

# Key

src/string.ts#L1

string | number | symbol

# LLength – Ask TS to re-check that A1 extends A2. And if it fails, A2 will be enforced anyway. Can also be used to add constraints on parameters.

src/string.ts#L40

L ["length"]

# List

src/string.ts#L2

ReadonlyArray<A>

# Literal

src/string.ts#L11

string | number | bigint | boolean

# Pop

src/string.ts#L63

L extends readonly [ rest, any ] | readonly [ rest, optional ] ? LBody : L

# _Replace

src/string.ts#L47

S extends template-literal ? Replace<template-literal, R, W> : S

# __Split

src/string.ts#L50

S extends template-literal ? __Split<AS, D, [ rest, BS ]> : [ rest, S ]

# String

src/string.ts#L1

# At

src/string.ts#L10

AAt<Split<S, "">, K>

# Join – Concat many literals together

src/string.ts#L24

_Join<T, D> extends inferred ? Cast<X, string> : never

# Length

src/string.ts#L43

LLength<Split<S, "">>

# Replace

src/string.ts#L44

_Replace<S, R, W> extends inferred ? Cast<X, string> : never

# Split – Split S by D into a [[List]]

src/string.ts#L62

_Split<S, D> extends inferred ? Cast<X, string []> : never

# CustomElement

src/everyday-types.ts#L83

# attributeChangedCallback(name, oldValue, newValue) – Callback that is invoked when one of the {@link withProperties} changes.

# name – Name of attribute

string

# oldValue – Old value

null | string

# newValue – New value

null | string

attributeChangedCallback(name, oldValue, newValue)  =>

# connectedCallback() – Invoked when the component is added to the document's DOM.

In connectedCallback() you should setup tasks that should only occur when the element is connected to the document. The most common of these is adding event listeners to nodes external to the element, like a keydown event handler added to the window.

connectedCallback() {
  super.connectedCallback();
  this.addEventListener('keydown', this._handleKeydown);
}

Typically, anything done in connectedCallback() should be undone when the element is disconnected, in disconnectedCallback().

connectedCallback()  =>

# disconnectedCallback() – Invoked when the component is removed from the document's DOM.

This callback is the main signal to the element that it may no longer be used. disconnectedCallback() should ensure that nothing is holding a reference to the element (such as event listeners added to nodes external to the element), so that it is free to be garbage collected.

disconnectedCallback() {
  super.disconnectedCallback();
  window.removeEventListener('keydown', this._handleKeydown);
}

An element may be re-connected after being disconnected.

disconnectedCallback()  =>

# EventHandler

src/everyday-types.ts#L7

# this

T

# event

E & {

# currentTarget

src/everyday-types.ts#L8

T

# target

src/everyday-types.ts#L8

Element

EventHandler(this, event)  =>

# SafeMap

src/everyday-types.ts#L62

# get(v)

# v

K

get(v)  =>

T

# has(v)

# v

K

has(v)  =>

# SafeWeakMap

src/everyday-types.ts#L67

# get(v)

# v

K

get(v)  =>

T

# has(v)

# v

K

has(v)  =>

# Any

src/everyday-types.ts#L60

any

# Chunk

src/everyday-types.ts#L3

N extends N ? number extends N ? T [] : _Chunk<T, N, [ ]> : never

# Class

src/everyday-types.ts#L5

# (args)

src/everyday-types.ts#L5

# new()

T

# args

any []

# Ctor

src/everyday-types.ts#L6

# (args)

src/everyday-types.ts#L6

# new()

unknown

# args

any []

# CustomElementConstructor

src/everyday-types.ts#L74

Class<CustomElement> & {}

# DetailOf

src/everyday-types.ts#L54

Narrow<Parameters<Narrow<Get<T, K>, Fn<any, any>>> [0], CustomEvent> ["detail"]

# EventKeys

src/everyday-types.ts#L10

keyof EventsOf<T>

# EventsOf

src/everyday-types.ts#L33

[K in Keys<T> ]-?: Narrow<Parameters<Narrow<Get<T, K>, Fn<any, any>>> [0], Event>

# Fn

src/everyday-types.ts#L11

# (args)

# args

T

(args)  =>

R

# Get

src/everyday-types.ts#L12

T [NarrowKey<K, T>]

# Key

src/everyday-types.ts#L13

number | string | symbol

# Keys

src/everyday-types.ts#L14

keyof [K in keyof T ]: StringOf<K>

# Mixable

src/everyday-types.ts#L15

{} & Omit<T, "constructor">

# Mutable

src/everyday-types.ts#L16

[P in keyof T ]: T [P]

# Narrow

src/everyday-types.ts#L18

K extends T ? K : never

# NarrowKey

src/everyday-types.ts#L17

Narrow<K, keyof T>

# NonNull

src/everyday-types.ts#L19

[K in Keys<T> ]: T [K]

# Null

src/everyday-types.ts#L20

null | undefined | void

# ObjectFromList

src/everyday-types.ts#L22

[K in T extends ReadonlyArray<inferred> ? U : never ]: V

# Prefix

src/everyday-types.ts#L25

template-literal

# SansOn

src/everyday-types.ts#L26

String.Split<StringOf<T>, " on">

# StringKeys

src/everyday-types.ts#L27

StringOf<keyof T>

# StringLiteral

src/everyday-types.ts#L28

T extends string ? string extends T ? never : T : never

# StringOf

src/everyday-types.ts#L29

Narrow<T, string>

# Target

src/everyday-types.ts#L30

HTMLElement | SVGElement | Window | Document | ShadowRoot

# ValueConstructor

src/everyday-types.ts#L72

StringConstructor | NumberConstructor | BooleanConstructor

# ValuesOf

src/everyday-types.ts#L31

T [keyof T]

# _Chunk

src/everyday-types.ts#L4

R ["length"] extends N ? R : _Chunk<T, N, [ T, rest ]>

Credits

• ts-toolbelt by Pierre-Antoine Mills – TypeScript's largest utility library

Contributing

Fork or edit and submit a PR.

All contributions are welcome!

License

MIT © 2022 stagas